MOwNiT

Lab4

Zad1

Julia times

C times

C times optimized

Fitting polynomials

Julia times

C times

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/times.h>
#include <gsl/gsl_blas.h>
#include <gsl/gsl_matrix.h>

double** create_arr(int N, int M){
    double** arr = malloc(N * sizeof(double*));
    for (int i = 0 ; i < N ; i++){
        arr[i] = malloc(M * sizeof(double));
    }
    for (int i = 0 ; i < N ; i++){
        for (int j = 0 ; j < M ; j++){
            arr[i][j] = rand();
        }
    }
    return arr;
}

void remove_arr(int N, double** arr){
    for (int i = 0 ; i < N ; i++){
        free(arr[i]);
    }
    free(arr);
}


gsl_matrix* create_gsl_matrix(int N, int M){
    gsl_matrix* arr = gsl_matrix_alloc(N,M);
    for (size_t i = 0 ; i < N ; i ++){
        for (size_t j = 0 ; j < M ; j++){
            gsl_matrix_set(arr, i, j, rand());
        }
    }
    return arr;
}



void print_arr(int N, int M, double **arr){
    for (int i = 0 ; i < N ; i++){
        for (int j = 0 ; j < M ; j++){
            printf("%f ", arr[i][j]);
        }
        printf("\n");
    }
}


double** naive_multiplication(int N1, int N2, int M1, int M2, double** A, double** B){
    if (N2 != M1){
        printf("%s\n", "Invalid size of arrays");
        exit(1);
    }

    double** C = malloc(N1 * sizeof(double*));
    for (int i = 0 ; i < N1 ; i++){
        C[i] = malloc(M2 * sizeof(double));
    }

    for (int i = 0 ; i < N1 ; i++){
        for (int j = 0 ; j < M2 ; j++){
            for (int k = 0 ; k < N2 ; k++){
                C[i][j] = C[i][j] + A[i][k] * B[k][j];
            }
        }
    }

    return C;
}


double** better_multiplication(int N1, int N2, int M1, int M2, double** A, double** B){
    if (N2 != M1){
        printf("%s\n", "Invalid size of arrays");
        exit(1);
    }

    double** C = malloc(N1 * sizeof(double*));
    for (int i = 0 ; i < N1 ; i++){
        C[i] = malloc(M2 * sizeof(double));
    }

    for (int i = 0 ; i < N1 ; i++){
        for (int k = 0 ; k < N2 ; k++){
            for (int j = 0 ; j < M2 ; j++){
                C[i][j] = C[i][j] + A[i][k] * B[k][j];
            }
        }
    }

    return C;
}



int main()
{
    srand ( time ( NULL));
    clock_t start, end;
    double real_time = 0;
    double* naive_times = malloc(190 * sizeof(double));
    double* better_times = malloc(190 * sizeof(double));
    double* blas_times = malloc(190 * sizeof(double));

    int k = 0;
    for (int size = 100 ; size <= 1000 ; size = size + 50){
        double** A = create_arr(size,size);
        double** B = create_arr(size,size);
        gsl_matrix* A2 = create_gsl_matrix(size,size);
        gsl_matrix* B2 = create_gsl_matrix(size,size);
        printf("size %d\n", size);
        for (int i = 0 ; i < 10 ; i++){
            start = clock();
            double** C1 = naive_multiplication(size,size,size,size,A,B);
            end = clock();
            real_time = (double)(end - start) *1000.0 / CLOCKS_PER_SEC;
            naive_times[(k*10)+i] = real_time;
            remove_arr(size, C1);

            start = clock();
            double** C2 = better_multiplication(size,size,size,size,A,B);
            end = clock();
            real_time = (double)(end - start) *1000.0 / CLOCKS_PER_SEC;
            better_times[(k*10)+i] = real_time;
            remove_arr(size, C2);

            gsl_matrix* C3 = create_gsl_matrix(size,size);
            start = clock();
            gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, A2, B2, 0.0, C3); 
            end = clock();
            real_time = (double)(end - start) *1000.0 / CLOCKS_PER_SEC;
            blas_times[(k*10)+i] = real_time;
            gsl_matrix_free(C3);

        }
        remove_arr(size,A);
        remove_arr(size,B);
        gsl_matrix_free(A2);
        gsl_matrix_free(B2);
        k++;
    }

    FILE *f;
    f = fopen("c_times.csv", "w+");
    fprintf(f,"Size, Naive, Better, Blas\n");

    k = 0;
    for (int i = 100 ; i <= 1000 ; i = i + 50){
        for (int j = 0 ; j < 10 ; j++){
            fprintf(f,"%d, %f, %f, %f\n", i, naive_times[k], better_times[k], blas_times[k]);
            k++;
        }
    }

    fclose(f);
    free(naive_times);
    free(better_times);
    free(blas_times);

    return 0;
}

C times optimized

Zad2

Zad 3